home *** CD-ROM | disk | FTP | other *** search
/ Language/OS - Multiplatform Resource Library / LANGUAGE OS.iso / cocktail / reuse.lha / reuse / m2c / Errors.c < prev    next >
C/C++ Source or Header  |  1992-08-18  |  15KB  |  606 lines
  1. #include "SYSTEM_.h"
  2.  
  3. #ifndef DEFINITION_Memory
  4. #include "Memory.h"
  5. #endif
  6.  
  7. #ifndef DEFINITION_IO
  8. #include "IO.h"
  9. #endif
  10.  
  11. #ifndef DEFINITION_Positions
  12. #include "Positions.h"
  13. #endif
  14.  
  15. #ifndef DEFINITION_StringMem
  16. #include "StringMem.h"
  17. #endif
  18.  
  19. #ifndef DEFINITION_Strings
  20. #include "Strings.h"
  21. #endif
  22.  
  23. #ifndef DEFINITION_Idents
  24. #include "Idents.h"
  25. #endif
  26.  
  27. #ifndef DEFINITION_Sets
  28. #include "Sets.h"
  29. #endif
  30.  
  31. #ifndef DEFINITION_Sort
  32. #include "Sort.h"
  33. #endif
  34.  
  35. #ifndef DEFINITION_System
  36. #include "System.h"
  37. #endif
  38.  
  39. #ifndef DEFINITION_Strings
  40. #include "Strings.h"
  41. #endif
  42.  
  43. #ifndef DEFINITION_Errors
  44. #include "Errors.h"
  45. #endif
  46.  
  47. PROC Errors_Exit;
  48.  
  49. #define MaxError    100
  50. typedef struct S_1 {
  51.     CHAR A[255 + 1];
  52. } tArray;
  53. typedef struct S_2 {
  54.     Positions_tPosition Position;
  55.     BOOLEAN IsErrorCode;
  56.     SHORTCARD ErrorNumber;
  57.     SHORTCARD ErrorCode;
  58.     SHORTCARD ErrorClass;
  59.     SHORTCARD InfoClass;
  60.     union {
  61.         struct {
  62.             char dummy;
  63.         } V_1;
  64.         struct {
  65.             INTEGER vInteger;
  66.         } V_2;
  67.         struct {
  68.             INTEGER vShort;
  69.         } V_3;
  70.         struct {
  71.             INTEGER vLong;
  72.         } V_4;
  73.         struct {
  74.             REAL vReal;
  75.         } V_5;
  76.         struct {
  77.             BOOLEAN vBoolean;
  78.         } V_6;
  79.         struct {
  80.             CHAR vCharacter;
  81.         } V_7;
  82.         struct {
  83.             StringMem_tStringRef vString;
  84.         } V_8;
  85.         struct {
  86.             StringMem_tStringRef vArray;
  87.         } V_9;
  88.         struct {
  89.             Sets_tSet *vSet;
  90.         } V_10;
  91.         struct {
  92.             Idents_tIdent vIdent;
  93.         } V_11;
  94.     } U_1;
  95. } tError;
  96. static struct S_3 {
  97.     tError A[MaxError + 1];
  98. } ErrorTable;
  99. static INTEGER MessageCount;
  100. static BOOLEAN IsStore;
  101. static void (*HandleMessage) ARGS((BOOLEAN, CARDINAL, CARDINAL, Positions_tPosition, CARDINAL, ADDRESS));
  102. static IO_tFile Out;
  103. static void WriteHead ARGS((Positions_tPosition Position, CARDINAL ErrorClass));
  104. static void WriteCode ARGS((CARDINAL ErrorCode));
  105. static void WriteInfo ARGS((CARDINAL InfoClass, ADDRESS Info));
  106. static void WriteMessage ARGS((BOOLEAN IsErrorCode, CARDINAL ErrorCode, CARDINAL ErrorClass, Positions_tPosition Position, CARDINAL InfoClass, ADDRESS Info));
  107. static void StoreMessage ARGS((BOOLEAN pIsErrorCode, CARDINAL pErrorCode, CARDINAL pErrorClass, Positions_tPosition pPosition, CARDINAL pInfoClass, ADDRESS pInfo));
  108. static BOOLEAN IsLess ARGS((INTEGER i, INTEGER j));
  109. static void Swap ARGS((INTEGER i, INTEGER j));
  110. static void yyExit ARGS(());
  111.  
  112.  
  113. void Errors_ErrorMessage
  114. # ifdef __STDC__
  115. (CARDINAL ErrorCode, CARDINAL ErrorClass, Positions_tPosition Position)
  116. # else
  117. (ErrorCode, ErrorClass, Position)
  118. CARDINAL ErrorCode, ErrorClass;
  119. Positions_tPosition Position;
  120. # endif
  121. {
  122.   (*HandleMessage)(TRUE, ErrorCode, ErrorClass, Position, (LONGCARD)Errors_None, (ADDRESS)NIL);
  123. }
  124.  
  125. void Errors_ErrorMessageI
  126. # ifdef __STDC__
  127. (CARDINAL ErrorCode, CARDINAL ErrorClass, Positions_tPosition Position, CARDINAL InfoClass, ADDRESS Info)
  128. # else
  129. (ErrorCode, ErrorClass, Position, InfoClass, Info)
  130. CARDINAL ErrorCode, ErrorClass;
  131. Positions_tPosition Position;
  132. CARDINAL InfoClass;
  133. ADDRESS Info;
  134. # endif
  135. {
  136.   (*HandleMessage)(TRUE, ErrorCode, ErrorClass, Position, InfoClass, Info);
  137. }
  138.  
  139. void Errors_Message
  140. # ifdef __STDC__
  141. (CHAR ErrorText[], LONGCARD O_1, CARDINAL ErrorClass, Positions_tPosition Position)
  142. # else
  143. (ErrorText, O_1, ErrorClass, Position)
  144. CHAR ErrorText[];
  145. LONGCARD O_1;
  146. CARDINAL ErrorClass;
  147. Positions_tPosition Position;
  148. # endif
  149. {
  150.   Strings_tString String;
  151.   OPEN_ARRAY_LOCALS
  152.  
  153.   ALLOC_OPEN_ARRAYS(O_1 * sizeof(CHAR), 1)
  154.   COPY_OPEN_ARRAY(ErrorText, O_1, CHAR)
  155.   Strings_ArrayToString(ErrorText, O_1, &String);
  156.   (*HandleMessage)(FALSE, (LONGCARD)Idents_MakeIdent(&String), ErrorClass, Position, (LONGCARD)Errors_None, (ADDRESS)NIL);
  157.   FREE_OPEN_ARRAYS
  158. }
  159.  
  160. void Errors_MessageI
  161. # ifdef __STDC__
  162. (CHAR ErrorText[], LONGCARD O_2, CARDINAL ErrorClass, Positions_tPosition Position, CARDINAL InfoClass, ADDRESS Info)
  163. # else
  164. (ErrorText, O_2, ErrorClass, Position, InfoClass, Info)
  165. CHAR ErrorText[];
  166. LONGCARD O_2;
  167. CARDINAL ErrorClass;
  168. Positions_tPosition Position;
  169. CARDINAL InfoClass;
  170. ADDRESS Info;
  171. # endif
  172. {
  173.   Strings_tString String;
  174.   OPEN_ARRAY_LOCALS
  175.  
  176.   ALLOC_OPEN_ARRAYS(O_2 * sizeof(CHAR), 1)
  177.   COPY_OPEN_ARRAY(ErrorText, O_2, CHAR)
  178.   Strings_ArrayToString(ErrorText, O_2, &String);
  179.   (*HandleMessage)(FALSE, (LONGCARD)Idents_MakeIdent(&String), ErrorClass, Position, InfoClass, Info);
  180.   FREE_OPEN_ARRAYS
  181. }
  182.  
  183. static void WriteHead
  184. # ifdef __STDC__
  185. (Positions_tPosition Position, CARDINAL ErrorClass)
  186. # else
  187. (Position, ErrorClass)
  188. Positions_tPosition Position;
  189. CARDINAL ErrorClass;
  190. # endif
  191. {
  192.   Positions_WritePosition(Out, Position);
  193.   IO_WriteS(Out, (STRING)": ", 2L);
  194.   switch (ErrorClass) {
  195.   case Errors_Fatal:;
  196.     IO_WriteS(Out, (STRING)"Fatal       ", 12L);
  197.     break;
  198.   case Errors_Restriction:;
  199.     IO_WriteS(Out, (STRING)"Restriction ", 12L);
  200.     break;
  201.   case Errors_Error:;
  202.     IO_WriteS(Out, (STRING)"Error       ", 12L);
  203.     break;
  204.   case Errors_Warning:;
  205.     IO_WriteS(Out, (STRING)"Warning     ", 12L);
  206.     break;
  207.   case Errors_Repair:;
  208.     IO_WriteS(Out, (STRING)"Repair      ", 12L);
  209.     break;
  210.   case Errors_Note:;
  211.     IO_WriteS(Out, (STRING)"Note        ", 12L);
  212.     break;
  213.   case Errors_Information:;
  214.     IO_WriteS(Out, (STRING)"Information ", 12L);
  215.     break;
  216.   default :
  217.     IO_WriteS(Out, (STRING)"Error class: ", 13L);
  218.     IO_WriteI(Out, (LONGINT)ErrorClass, 0L);
  219.     break;
  220.   }
  221. }
  222.  
  223. static void WriteCode
  224. # ifdef __STDC__
  225. (CARDINAL ErrorCode)
  226. # else
  227. (ErrorCode)
  228. CARDINAL ErrorCode;
  229. # endif
  230. {
  231.   switch (ErrorCode) {
  232.   case Errors_NoText:;
  233.     break;
  234.   case Errors_SyntaxError:;
  235.     IO_WriteS(Out, (STRING)"syntax error", 12L);
  236.     break;
  237.   case Errors_ExpectedTokens:;
  238.     IO_WriteS(Out, (STRING)"expected tokens", 15L);
  239.     break;
  240.   case Errors_RestartPoint:;
  241.     IO_WriteS(Out, (STRING)"restart point", 13L);
  242.     break;
  243.   case Errors_TokenInserted:;
  244.     IO_WriteS(Out, (STRING)"token inserted ", 15L);
  245.     break;
  246.   case Errors_WrongParseTable:;
  247.     IO_WriteS(Out, (STRING)"parse table mismatch", 20L);
  248.     break;
  249.   case Errors_OpenParseTable:;
  250.     IO_WriteS(Out, (STRING)"cannot open parse table", 23L);
  251.     break;
  252.   case Errors_ReadParseTable:;
  253.     IO_WriteS(Out, (STRING)"cannot read parse table", 23L);
  254.     break;
  255.   case Errors_TooManyErrors:;
  256.     IO_WriteS(Out, (STRING)"too many errors", 15L);
  257.     break;
  258.   default :
  259.     IO_WriteS(Out, (STRING)" error code: ", 13L);
  260.     IO_WriteI(Out, (LONGINT)ErrorCode, 0L);
  261.     break;
  262.   }
  263. }
  264.  
  265. static void WriteInfo
  266. # ifdef __STDC__
  267. (CARDINAL InfoClass, ADDRESS Info)
  268. # else
  269. (InfoClass, Info)
  270. CARDINAL InfoClass;
  271. ADDRESS Info;
  272. # endif
  273. {
  274.   INTEGER *PtrToInteger;
  275.   SHORTCARD *PtrToShort;
  276.   LONGINT *PtrToLong;
  277.   REAL *PtrToReal;
  278.   BOOLEAN *PtrToBoolean;
  279.   CHAR *PtrToCharacter;
  280.   Strings_tString *PtrToString;
  281.   tArray *PtrToArray;
  282.   Idents_tIdent *PtrToIdent;
  283.  
  284.   if (InfoClass == Errors_None) {
  285.     return;
  286.   }
  287.   IO_WriteS(Out, (STRING)": ", 2L);
  288.   switch (InfoClass) {
  289.   case Errors_Integer:;
  290.     PtrToInteger = (LONGINT *)Info;
  291.     IO_WriteI(Out, *PtrToInteger, 0L);
  292.     break;
  293.   case Errors_Short:;
  294.     PtrToShort = (SHORTCARD *)Info;
  295.     IO_WriteI(Out, (LONGINT)(*PtrToShort), 0L);
  296.     break;
  297.   case Errors_Long:;
  298.     PtrToLong = (LONGINT *)Info;
  299.     IO_WriteI(Out, *PtrToLong, 0L);
  300.     break;
  301.   case Errors_Real:;
  302.     PtrToReal = (REAL *)Info;
  303.     IO_WriteR(Out, *PtrToReal, 1L, 10L, 1L);
  304.     break;
  305.   case Errors_Boolean:;
  306.     PtrToBoolean = (BOOLEAN *)Info;
  307.     IO_WriteB(Out, *PtrToBoolean);
  308.     break;
  309.   case Errors_Character:;
  310.     PtrToCharacter = (CHAR *)Info;
  311.     IO_WriteC(Out, *PtrToCharacter);
  312.     break;
  313.   case Errors_String:;
  314.     PtrToString = (Strings_tString *)Info;
  315.     Strings_WriteS(Out, PtrToString);
  316.     break;
  317.   case Errors_Array:;
  318.     PtrToArray = (tArray *)Info;
  319.     IO_WriteS(Out, (*PtrToArray).A, 256L);
  320.     break;
  321.   case Errors_Ident:;
  322.     PtrToIdent = (SHORTCARD *)Info;
  323.     Idents_WriteIdent(Out, *PtrToIdent);
  324.     break;
  325.   default :
  326.     break;
  327.   }
  328. }
  329.  
  330. static void WriteMessage
  331. # ifdef __STDC__
  332. (BOOLEAN IsErrorCode, CARDINAL ErrorCode, CARDINAL ErrorClass, Positions_tPosition Position, CARDINAL InfoClass, ADDRESS Info)
  333. # else
  334. (IsErrorCode, ErrorCode, ErrorClass, Position, InfoClass, Info)
  335. BOOLEAN IsErrorCode;
  336. CARDINAL ErrorCode, ErrorClass;
  337. Positions_tPosition Position;
  338. CARDINAL InfoClass;
  339. ADDRESS Info;
  340. # endif
  341. {
  342.   WriteHead(Position, ErrorClass);
  343.   if (IsErrorCode) {
  344.     WriteCode(ErrorCode);
  345.   } else {
  346.     Idents_WriteIdent(Out, (SHORTCARD)ErrorCode);
  347.   }
  348.   WriteInfo(InfoClass, Info);
  349.   IO_WriteNl(Out);
  350.   if (ErrorClass == Errors_Fatal && !IsStore) {
  351.     (*Errors_Exit)();
  352.   }
  353. }
  354.  
  355. void Errors_WriteMessages
  356. # ifdef __STDC__
  357. (IO_tFile File)
  358. # else
  359. (File)
  360. IO_tFile File;
  361. # endif
  362. {
  363.   INTEGER i;
  364.   ADDRESS Info;
  365.   Strings_tString s;
  366.  
  367.   Sort_Sort(1L, MessageCount, (Sort_tProcIntIntBool)IsLess, (Sort_tProcIntInt)Swap);
  368.   Out = File;
  369.   {
  370.     LONGINT B_1 = 1, B_2 = MessageCount;
  371.  
  372.     if (B_1 <= B_2)
  373.       for (i = B_1;; i += 1) {
  374.         {
  375.           register tError *W_1 = &ErrorTable.A[i];
  376.  
  377.           switch (W_1->InfoClass) {
  378.           case Errors_Integer:;
  379.             Info = ADR(W_1->U_1.V_2.vInteger);
  380.             break;
  381.           case Errors_Short:;
  382.             Info = ADR(W_1->U_1.V_3.vShort);
  383.             break;
  384.           case Errors_Long:;
  385.             Info = ADR(W_1->U_1.V_4.vLong);
  386.             break;
  387.           case Errors_Real:;
  388.             Info = ADR(W_1->U_1.V_5.vReal);
  389.             break;
  390.           case Errors_Boolean:;
  391.             Info = ADR(W_1->U_1.V_6.vBoolean);
  392.             break;
  393.           case Errors_Character:;
  394.             Info = ADR(W_1->U_1.V_7.vCharacter);
  395.             break;
  396.           case Errors_String:;
  397.             StringMem_GetString(W_1->U_1.V_8.vString, &s);
  398.             Info = ADR(s);
  399.             break;
  400.           case Errors_Set:;
  401.             Info = (ADDRESS)W_1->U_1.V_10.vSet;
  402.             break;
  403.           case Errors_Ident:;
  404.             Info = ADR(W_1->U_1.V_11.vIdent);
  405.             break;
  406.           default :
  407.             break;
  408.           }
  409.           WriteMessage(W_1->IsErrorCode, (LONGCARD)W_1->ErrorCode, (LONGCARD)W_1->ErrorClass, W_1->Position, (LONGCARD)W_1->InfoClass, Info);
  410.         }
  411.         if (i >= B_2) break;
  412.       }
  413.   }
  414.   Out = IO_StdError;
  415. }
  416.  
  417. static void StoreMessage
  418. # ifdef __STDC__
  419. (BOOLEAN pIsErrorCode, CARDINAL pErrorCode, CARDINAL pErrorClass, Positions_tPosition pPosition, CARDINAL pInfoClass, ADDRESS pInfo)
  420. # else
  421. (pIsErrorCode, pErrorCode, pErrorClass, pPosition, pInfoClass, pInfo)
  422. BOOLEAN pIsErrorCode;
  423. CARDINAL pErrorCode, pErrorClass;
  424. Positions_tPosition pPosition;
  425. CARDINAL pInfoClass;
  426. ADDRESS pInfo;
  427. # endif
  428. {
  429.   INTEGER *PtrToInteger;
  430.   SHORTCARD *PtrToShort;
  431.   LONGINT *PtrToLong;
  432.   REAL *PtrToReal;
  433.   BOOLEAN *PtrToBoolean;
  434.   CHAR *PtrToCharacter;
  435.   Strings_tString *PtrToString;
  436.   tArray *PtrToArray;
  437.   Sets_tSet *PtrToSet;
  438.   Idents_tIdent *PtrToIdent;
  439.   Strings_tString s;
  440.  
  441.   if (MessageCount < MaxError) {
  442.     INC(MessageCount);
  443.     {
  444.       register tError *W_2 = &ErrorTable.A[MessageCount];
  445.  
  446.       W_2->Position = pPosition;
  447.       W_2->IsErrorCode = pIsErrorCode;
  448.       W_2->ErrorNumber = MessageCount;
  449.       W_2->ErrorCode = pErrorCode;
  450.       W_2->ErrorClass = pErrorClass;
  451.       W_2->InfoClass = pInfoClass;
  452.       switch (W_2->InfoClass) {
  453.       case Errors_Integer:;
  454.         PtrToInteger = (LONGINT *)pInfo;
  455.         W_2->U_1.V_2.vInteger = *PtrToInteger;
  456.         break;
  457.       case Errors_Short:;
  458.         PtrToShort = (SHORTCARD *)pInfo;
  459.         W_2->U_1.V_3.vShort = *PtrToShort;
  460.         break;
  461.       case Errors_Long:;
  462.         PtrToLong = (LONGINT *)pInfo;
  463.         W_2->U_1.V_4.vLong = *PtrToLong;
  464.         break;
  465.       case Errors_Real:;
  466.         PtrToReal = (REAL *)pInfo;
  467.         W_2->U_1.V_5.vReal = *PtrToReal;
  468.         break;
  469.       case Errors_Boolean:;
  470.         PtrToBoolean = (BOOLEAN *)pInfo;
  471.         W_2->U_1.V_6.vBoolean = *PtrToBoolean;
  472.         break;
  473.       case Errors_Character:;
  474.         PtrToCharacter = (CHAR *)pInfo;
  475.         W_2->U_1.V_7.vCharacter = *PtrToCharacter;
  476.         break;
  477.       case Errors_String:;
  478.         PtrToString = (Strings_tString *)pInfo;
  479.         W_2->U_1.V_8.vString = StringMem_PutString(PtrToString);
  480.         break;
  481.       case Errors_Array:;
  482.         PtrToArray = (tArray *)pInfo;
  483.         Strings_ArrayToString((*PtrToArray).A, 256L, &s);
  484.         W_2->InfoClass = Errors_String;
  485.         W_2->U_1.V_9.vArray = StringMem_PutString(&s);
  486.         break;
  487.       case Errors_Set:;
  488.         PtrToSet = (Sets_tSet *)pInfo;
  489.         W_2->U_1.V_10.vSet = (Sets_tSet *)Memory_Alloc((LONGINT)sizeof(Sets_tSet));
  490.         Sets_MakeSet(W_2->U_1.V_10.vSet, Sets_Size(PtrToSet));
  491.         Sets_Assign(W_2->U_1.V_10.vSet, *PtrToSet);
  492.         break;
  493.       case Errors_Ident:;
  494.         PtrToIdent = (SHORTCARD *)pInfo;
  495.         W_2->U_1.V_11.vIdent = *PtrToIdent;
  496.         break;
  497.       default :
  498.         break;
  499.       }
  500.     }
  501.   } else {
  502.     {
  503.       register tError *W_3 = &ErrorTable.A[MessageCount];
  504.  
  505.       W_3->IsErrorCode = TRUE;
  506.       W_3->ErrorCode = Errors_TooManyErrors;
  507.       W_3->ErrorClass = Errors_Restriction;
  508.       W_3->InfoClass = Errors_None;
  509.     }
  510.   }
  511.   if (pErrorClass == Errors_Fatal) {
  512.     Errors_WriteMessages((System_tFile)IO_StdError);
  513.     (*Errors_Exit)();
  514.   }
  515. }
  516.  
  517. static BOOLEAN IsLess
  518. # ifdef __STDC__
  519. (INTEGER i, INTEGER j)
  520. # else
  521. (i, j)
  522. INTEGER i, j;
  523. # endif
  524. {
  525.   INTEGER r;
  526.  
  527.   r = Positions_Compare(ErrorTable.A[i].Position, ErrorTable.A[j].Position);
  528.   if (r == -1) {
  529.     return TRUE;
  530.   }
  531.   if (r == 1) {
  532.     return FALSE;
  533.   }
  534.   return ErrorTable.A[i].ErrorNumber < ErrorTable.A[j].ErrorNumber;
  535. }
  536.  
  537. static void Swap
  538. # ifdef __STDC__
  539. (INTEGER i, INTEGER j)
  540. # else
  541. (i, j)
  542. INTEGER i, j;
  543. # endif
  544. {
  545.   tError t;
  546.  
  547.   t = ErrorTable.A[i];
  548.   ErrorTable.A[i] = ErrorTable.A[j];
  549.   ErrorTable.A[j] = t;
  550. }
  551.  
  552. void Errors_StoreMessages
  553. # ifdef __STDC__
  554. (BOOLEAN Store)
  555. # else
  556. (Store)
  557. BOOLEAN Store;
  558. # endif
  559. {
  560.   if (Store) {
  561.     HandleMessage = StoreMessage;
  562.     MessageCount = 0;
  563.   } else {
  564.     HandleMessage = WriteMessage;
  565.   }
  566.   IsStore = Store;
  567. }
  568.  
  569. static void yyExit
  570. # ifdef __STDC__
  571. ()
  572. # else
  573. ()
  574. # endif
  575. {
  576.   IO_CloseIO();
  577.   Exit(1L);
  578. }
  579.  
  580. void BEGIN_Errors()
  581. {
  582.   static BOOLEAN has_been_called = FALSE;
  583.  
  584.   if (!has_been_called) {
  585.     has_been_called = TRUE;
  586.  
  587.     BEGIN_Positions();
  588.     BEGIN_IO();
  589.     BEGIN_Memory();
  590.     BEGIN_IO();
  591.     BEGIN_Positions();
  592.     BEGIN_StringMem();
  593.     BEGIN_Strings();
  594.     BEGIN_Idents();
  595.     BEGIN_Sets();
  596.     BEGIN_Sort();
  597.     BEGIN_System();
  598.     BEGIN_Strings();
  599.  
  600.     Errors_Exit = yyExit;
  601.     IsStore = FALSE;
  602.     Out = IO_StdError;
  603.     HandleMessage = WriteMessage;
  604.   }
  605. }
  606.